{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: foward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:\n",
    "\n",
    "---\n",
    "公式：\n",
    "$$\n",
    "Y = X\\cdot w + b\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking.\n",
    "\n",
    "---\n",
    "公式：\n",
    "$$\n",
    "dX = dY\\cdot w^T\\\\\n",
    "dw = X^T\\cdot dY\\\\\n",
    "db = \\sum_{axis=0}{dY}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:\n",
    "\n",
    "---\n",
    "ReLU层：合页函数，将负值置为零"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:\n",
    "\n",
    "---\n",
    "输入X中非负元素才能接收到上层传递的导数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "1. Sigmoid：输入值的绝对值很大时，梯度接近于0\n",
    "2. ReLU：输入值小于0时，梯度为0\n",
    "3. Leaky ReLU：不存在梯度为0的情况\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.12e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 2.85e-08\n",
      "b1 relative error: 1.56e-08\n",
      "b2 relative error: 7.76e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set.\n",
    "\n",
    "--- \n",
    "Solver 的作用是训练模型，而不是调参  \n",
    "每过一个 epoch 就将学习速率调整一次  \n",
    "每一个 epoch 中的迭代次数由 batch_size 在训练集中的占比确定"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 2440) loss: 2.303875\n",
      "(Epoch 0 / 20) train acc: 0.151000; val_acc: 0.146000\n",
      "(Iteration 101 / 2440) loss: 1.648814\n",
      "(Epoch 1 / 20) train acc: 0.390000; val_acc: 0.416000\n",
      "(Iteration 201 / 2440) loss: 1.596494\n",
      "(Epoch 2 / 20) train acc: 0.488000; val_acc: 0.470000\n",
      "(Iteration 301 / 2440) loss: 1.496337\n",
      "(Epoch 3 / 20) train acc: 0.484000; val_acc: 0.445000\n",
      "(Iteration 401 / 2440) loss: 1.321391\n",
      "(Epoch 4 / 20) train acc: 0.507000; val_acc: 0.474000\n",
      "(Iteration 501 / 2440) loss: 1.327890\n",
      "(Iteration 601 / 2440) loss: 1.331767\n",
      "(Epoch 5 / 20) train acc: 0.515000; val_acc: 0.503000\n",
      "(Iteration 701 / 2440) loss: 1.282000\n",
      "(Epoch 6 / 20) train acc: 0.529000; val_acc: 0.515000\n",
      "(Iteration 801 / 2440) loss: 1.149946\n",
      "(Epoch 7 / 20) train acc: 0.567000; val_acc: 0.494000\n",
      "(Iteration 901 / 2440) loss: 1.303060\n",
      "(Epoch 8 / 20) train acc: 0.565000; val_acc: 0.514000\n",
      "(Iteration 1001 / 2440) loss: 1.166435\n",
      "(Epoch 9 / 20) train acc: 0.588000; val_acc: 0.529000\n",
      "(Iteration 1101 / 2440) loss: 1.248509\n",
      "(Iteration 1201 / 2440) loss: 1.232033\n",
      "(Epoch 10 / 20) train acc: 0.599000; val_acc: 0.508000\n",
      "(Iteration 1301 / 2440) loss: 1.189771\n",
      "(Epoch 11 / 20) train acc: 0.610000; val_acc: 0.543000\n",
      "(Iteration 1401 / 2440) loss: 1.072381\n",
      "(Epoch 12 / 20) train acc: 0.604000; val_acc: 0.535000\n",
      "(Iteration 1501 / 2440) loss: 1.219574\n",
      "(Epoch 13 / 20) train acc: 0.607000; val_acc: 0.523000\n",
      "(Iteration 1601 / 2440) loss: 1.224184\n",
      "(Iteration 1701 / 2440) loss: 1.076106\n",
      "(Epoch 14 / 20) train acc: 0.620000; val_acc: 0.520000\n",
      "(Iteration 1801 / 2440) loss: 1.024133\n",
      "(Epoch 15 / 20) train acc: 0.592000; val_acc: 0.523000\n",
      "(Iteration 1901 / 2440) loss: 1.090859\n",
      "(Epoch 16 / 20) train acc: 0.650000; val_acc: 0.529000\n",
      "(Iteration 2001 / 2440) loss: 1.044584\n",
      "(Epoch 17 / 20) train acc: 0.623000; val_acc: 0.539000\n",
      "(Iteration 2101 / 2440) loss: 1.017646\n",
      "(Epoch 18 / 20) train acc: 0.665000; val_acc: 0.540000\n",
      "(Iteration 2201 / 2440) loss: 0.955345\n",
      "(Iteration 2301 / 2440) loss: 1.080513\n",
      "(Epoch 19 / 20) train acc: 0.656000; val_acc: 0.544000\n",
      "(Iteration 2401 / 2440) loss: 1.103811\n",
      "(Epoch 20 / 20) train acc: 0.638000; val_acc: 0.534000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet(hidden_dim=300, reg=1e-3)\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "solver = Solver(model, data, update_rule='sgd', optim_config={'learning_rate':1.2e-3,},\n",
    "                lr_decay=0.95, num_epochs=20, batch_size=400, print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 7.36e-09\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 3.48e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "---\n",
    "weight_scale 影响的是 W 初始分布（随机标准差）  \n",
    "本题降低 learning_rate 即可"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.363364\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.108000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.127000\n",
      "(Epoch 2 / 20) train acc: 0.440000; val_acc: 0.172000\n",
      "(Epoch 3 / 20) train acc: 0.500000; val_acc: 0.184000\n",
      "(Epoch 4 / 20) train acc: 0.540000; val_acc: 0.181000\n",
      "(Epoch 5 / 20) train acc: 0.740000; val_acc: 0.190000\n",
      "(Iteration 11 / 40) loss: 0.839976\n",
      "(Epoch 6 / 20) train acc: 0.740000; val_acc: 0.187000\n",
      "(Epoch 7 / 20) train acc: 0.740000; val_acc: 0.183000\n",
      "(Epoch 8 / 20) train acc: 0.820000; val_acc: 0.177000\n",
      "(Epoch 9 / 20) train acc: 0.860000; val_acc: 0.200000\n",
      "(Epoch 10 / 20) train acc: 0.920000; val_acc: 0.191000\n",
      "(Iteration 21 / 40) loss: 0.337174\n",
      "(Epoch 11 / 20) train acc: 0.960000; val_acc: 0.189000\n",
      "(Epoch 12 / 20) train acc: 0.940000; val_acc: 0.180000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.199000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.195000\n",
      "(Iteration 31 / 40) loss: 0.075911\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.182000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.201000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.207000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.192000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 1e-2   # Experiment with this!\n",
    "learning_rate = 1e-2  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs.\n",
    "\n",
    "--- \n",
    "本题通过增大 weight_scale 可达到模型收敛的目的，为什么？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.839886\n",
      "(Epoch 0 / 20) train acc: 0.220000; val_acc: 0.111000\n",
      "(Epoch 1 / 20) train acc: 0.240000; val_acc: 0.084000\n",
      "(Epoch 2 / 20) train acc: 0.420000; val_acc: 0.137000\n",
      "(Epoch 3 / 20) train acc: 0.440000; val_acc: 0.128000\n",
      "(Epoch 4 / 20) train acc: 0.700000; val_acc: 0.148000\n",
      "(Epoch 5 / 20) train acc: 0.740000; val_acc: 0.150000\n",
      "(Iteration 11 / 40) loss: 0.985188\n",
      "(Epoch 6 / 20) train acc: 0.780000; val_acc: 0.166000\n",
      "(Epoch 7 / 20) train acc: 0.900000; val_acc: 0.178000\n",
      "(Epoch 8 / 20) train acc: 0.940000; val_acc: 0.166000\n",
      "(Epoch 9 / 20) train acc: 0.940000; val_acc: 0.169000\n",
      "(Epoch 10 / 20) train acc: 0.900000; val_acc: 0.185000\n",
      "(Iteration 21 / 40) loss: 0.360608\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.182000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 13 / 20) train acc: 0.980000; val_acc: 0.200000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.188000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.179000\n",
      "(Iteration 31 / 40) loss: 0.075659\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.185000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.193000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.189000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.186000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.180000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-2  # Experiment with this!\n",
    "weight_scale = 4e-2   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "五层网络参数多，模型复杂，容易陷入局部极小值，对初始权重更敏感\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8.\n",
    "\n",
    "--- \n",
    "动量SGD法：速度累积，同时带有阻尼，因此梯度方向不变时可以加速训练，梯度方向改变时可以抑制振荡  \n",
    "公式不太一样？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.559978\n",
      "(Epoch 0 / 5) train acc: 0.104000; val_acc: 0.107000\n",
      "(Iteration 11 / 200) loss: 2.356069\n",
      "(Iteration 21 / 200) loss: 2.214091\n",
      "(Iteration 31 / 200) loss: 2.205928\n",
      "(Epoch 1 / 5) train acc: 0.225000; val_acc: 0.193000\n",
      "(Iteration 41 / 200) loss: 2.132095\n",
      "(Iteration 51 / 200) loss: 2.118950\n",
      "(Iteration 61 / 200) loss: 2.116443\n",
      "(Iteration 71 / 200) loss: 2.132549\n",
      "(Epoch 2 / 5) train acc: 0.298000; val_acc: 0.260000\n",
      "(Iteration 81 / 200) loss: 1.977227\n",
      "(Iteration 91 / 200) loss: 2.007528\n",
      "(Iteration 101 / 200) loss: 2.004762\n",
      "(Iteration 111 / 200) loss: 1.885342\n",
      "(Epoch 3 / 5) train acc: 0.343000; val_acc: 0.287000\n",
      "(Iteration 121 / 200) loss: 1.891517\n",
      "(Iteration 131 / 200) loss: 1.923677\n",
      "(Iteration 141 / 200) loss: 1.957744\n",
      "(Iteration 151 / 200) loss: 1.966736\n",
      "(Epoch 4 / 5) train acc: 0.322000; val_acc: 0.305000\n",
      "(Iteration 161 / 200) loss: 1.801483\n",
      "(Iteration 171 / 200) loss: 1.973779\n",
      "(Iteration 181 / 200) loss: 1.666572\n",
      "(Iteration 191 / 200) loss: 1.909494\n",
      "(Epoch 5 / 5) train acc: 0.372000; val_acc: 0.319000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 3.153777\n",
      "(Epoch 0 / 5) train acc: 0.099000; val_acc: 0.088000\n",
      "(Iteration 11 / 200) loss: 2.227203\n",
      "(Iteration 21 / 200) loss: 2.125706\n",
      "(Iteration 31 / 200) loss: 1.932679\n",
      "(Epoch 1 / 5) train acc: 0.308000; val_acc: 0.258000\n",
      "(Iteration 41 / 200) loss: 1.946329\n",
      "(Iteration 51 / 200) loss: 1.780464\n",
      "(Iteration 61 / 200) loss: 1.753502\n",
      "(Iteration 71 / 200) loss: 1.844626\n",
      "(Epoch 2 / 5) train acc: 0.377000; val_acc: 0.331000\n",
      "(Iteration 81 / 200) loss: 2.028389\n",
      "(Iteration 91 / 200) loss: 1.685416\n",
      "(Iteration 101 / 200) loss: 1.513204\n",
      "(Iteration 111 / 200) loss: 1.431671\n",
      "(Epoch 3 / 5) train acc: 0.469000; val_acc: 0.335000\n",
      "(Iteration 121 / 200) loss: 1.678510\n",
      "(Iteration 131 / 200) loss: 1.544807\n",
      "(Iteration 141 / 200) loss: 1.620010\n",
      "(Iteration 151 / 200) loss: 1.691080\n",
      "(Epoch 4 / 5) train acc: 0.483000; val_acc: 0.356000\n",
      "(Iteration 161 / 200) loss: 1.474016\n",
      "(Iteration 171 / 200) loss: 1.374763\n",
      "(Iteration 181 / 200) loss: 1.350309\n",
      "(Iteration 191 / 200) loss: 1.377182\n",
      "(Epoch 5 / 5) train acc: 0.505000; val_acc: 0.361000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/victorbian/.conda/envs/cs231n/lib/python3.7/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adam 注意点：t 需要预先加一"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.1395691798535431e-07\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 3.476928\n",
      "(Epoch 0 / 5) train acc: 0.126000; val_acc: 0.110000\n",
      "(Iteration 11 / 200) loss: 2.027712\n",
      "(Iteration 21 / 200) loss: 2.183358\n",
      "(Iteration 31 / 200) loss: 1.744257\n",
      "(Epoch 1 / 5) train acc: 0.363000; val_acc: 0.330000\n",
      "(Iteration 41 / 200) loss: 1.707951\n",
      "(Iteration 51 / 200) loss: 1.703835\n",
      "(Iteration 61 / 200) loss: 2.094758\n",
      "(Iteration 71 / 200) loss: 1.505514\n",
      "(Epoch 2 / 5) train acc: 0.416000; val_acc: 0.362000\n",
      "(Iteration 81 / 200) loss: 1.594391\n",
      "(Iteration 91 / 200) loss: 1.483393\n",
      "(Iteration 101 / 200) loss: 1.391985\n",
      "(Iteration 111 / 200) loss: 1.410419\n",
      "(Epoch 3 / 5) train acc: 0.496000; val_acc: 0.374000\n",
      "(Iteration 121 / 200) loss: 1.190327\n",
      "(Iteration 131 / 200) loss: 1.446230\n",
      "(Iteration 141 / 200) loss: 1.358681\n",
      "(Iteration 151 / 200) loss: 1.324699\n",
      "(Epoch 4 / 5) train acc: 0.512000; val_acc: 0.345000\n",
      "(Iteration 161 / 200) loss: 1.411795\n",
      "(Iteration 171 / 200) loss: 1.208069\n",
      "(Iteration 181 / 200) loss: 1.174987\n",
      "(Iteration 191 / 200) loss: 1.255647\n",
      "(Epoch 5 / 5) train acc: 0.554000; val_acc: 0.382000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.589166\n",
      "(Epoch 0 / 5) train acc: 0.119000; val_acc: 0.146000\n",
      "(Iteration 11 / 200) loss: 2.039570\n",
      "(Iteration 21 / 200) loss: 1.897350\n",
      "(Iteration 31 / 200) loss: 1.763338\n",
      "(Epoch 1 / 5) train acc: 0.382000; val_acc: 0.326000\n",
      "(Iteration 41 / 200) loss: 1.893851\n",
      "(Iteration 51 / 200) loss: 1.715672\n",
      "(Iteration 61 / 200) loss: 1.473092\n",
      "(Iteration 71 / 200) loss: 1.602196\n",
      "(Epoch 2 / 5) train acc: 0.434000; val_acc: 0.341000\n",
      "(Iteration 81 / 200) loss: 1.501205\n",
      "(Iteration 91 / 200) loss: 1.629006\n",
      "(Iteration 101 / 200) loss: 1.516101\n",
      "(Iteration 111 / 200) loss: 1.555156\n",
      "(Epoch 3 / 5) train acc: 0.471000; val_acc: 0.365000\n",
      "(Iteration 121 / 200) loss: 1.511333\n",
      "(Iteration 131 / 200) loss: 1.543257\n",
      "(Iteration 141 / 200) loss: 1.530261\n",
      "(Iteration 151 / 200) loss: 1.700269\n",
      "(Epoch 4 / 5) train acc: 0.515000; val_acc: 0.364000\n",
      "(Iteration 161 / 200) loss: 1.591097\n",
      "(Iteration 171 / 200) loss: 1.453837\n",
      "(Iteration 181 / 200) loss: 1.519405\n",
      "(Iteration 191 / 200) loss: 1.362337\n",
      "(Epoch 5 / 5) train acc: 0.528000; val_acc: 0.369000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "AdaGrad 累积梯度平方作为学习率的分母，会导致学习率过快下降（AdaGrad 是否有加快学习速度的作用？）  \n",
    "Adam 不存在该问题，因为它用的是指数加权平均\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 12250) loss: 2.345061\n",
      "(Epoch 0 / 25) train acc: 0.089000; val_acc: 0.104000\n",
      "(Iteration 101 / 12250) loss: 2.090368\n",
      "(Iteration 201 / 12250) loss: 1.934697\n",
      "(Iteration 301 / 12250) loss: 1.765255\n",
      "(Iteration 401 / 12250) loss: 1.888402\n",
      "(Epoch 1 / 25) train acc: 0.378000; val_acc: 0.369000\n",
      "(Iteration 501 / 12250) loss: 1.725892\n",
      "(Iteration 601 / 12250) loss: 1.665896\n",
      "(Iteration 701 / 12250) loss: 1.826446\n",
      "(Iteration 801 / 12250) loss: 1.841838\n",
      "(Iteration 901 / 12250) loss: 1.626861\n",
      "(Epoch 2 / 25) train acc: 0.414000; val_acc: 0.425000\n",
      "(Iteration 1001 / 12250) loss: 1.795147\n",
      "(Iteration 1101 / 12250) loss: 1.536360\n",
      "(Iteration 1201 / 12250) loss: 1.552462\n",
      "(Iteration 1301 / 12250) loss: 1.522753\n",
      "(Iteration 1401 / 12250) loss: 1.572801\n",
      "(Epoch 3 / 25) train acc: 0.461000; val_acc: 0.457000\n",
      "(Iteration 1501 / 12250) loss: 1.518038\n",
      "(Iteration 1601 / 12250) loss: 1.660571\n",
      "(Iteration 1701 / 12250) loss: 1.633762\n",
      "(Iteration 1801 / 12250) loss: 1.523522\n",
      "(Iteration 1901 / 12250) loss: 1.564335\n",
      "(Epoch 4 / 25) train acc: 0.464000; val_acc: 0.476000\n",
      "(Iteration 2001 / 12250) loss: 1.515513\n",
      "(Iteration 2101 / 12250) loss: 1.727960\n",
      "(Iteration 2201 / 12250) loss: 1.444961\n",
      "(Iteration 2301 / 12250) loss: 1.544888\n",
      "(Iteration 2401 / 12250) loss: 1.710698\n",
      "(Epoch 5 / 25) train acc: 0.491000; val_acc: 0.498000\n",
      "(Iteration 2501 / 12250) loss: 1.598883\n",
      "(Iteration 2601 / 12250) loss: 1.627098\n",
      "(Iteration 2701 / 12250) loss: 1.609067\n",
      "(Iteration 2801 / 12250) loss: 1.453573\n",
      "(Iteration 2901 / 12250) loss: 1.684776\n",
      "(Epoch 6 / 25) train acc: 0.517000; val_acc: 0.491000\n",
      "(Iteration 3001 / 12250) loss: 1.563584\n",
      "(Iteration 3101 / 12250) loss: 1.572580\n",
      "(Iteration 3201 / 12250) loss: 1.443919\n",
      "(Iteration 3301 / 12250) loss: 1.549850\n",
      "(Iteration 3401 / 12250) loss: 1.469846\n",
      "(Epoch 7 / 25) train acc: 0.508000; val_acc: 0.505000\n",
      "(Iteration 3501 / 12250) loss: 1.578141\n",
      "(Iteration 3601 / 12250) loss: 1.376654\n",
      "(Iteration 3701 / 12250) loss: 1.626048\n",
      "(Iteration 3801 / 12250) loss: 1.495368\n",
      "(Iteration 3901 / 12250) loss: 1.593813\n",
      "(Epoch 8 / 25) train acc: 0.549000; val_acc: 0.503000\n",
      "(Iteration 4001 / 12250) loss: 1.438514\n",
      "(Iteration 4101 / 12250) loss: 1.606450\n",
      "(Iteration 4201 / 12250) loss: 1.403860\n",
      "(Iteration 4301 / 12250) loss: 1.588814\n",
      "(Iteration 4401 / 12250) loss: 1.460065\n",
      "(Epoch 9 / 25) train acc: 0.526000; val_acc: 0.516000\n",
      "(Iteration 4501 / 12250) loss: 1.484477\n",
      "(Iteration 4601 / 12250) loss: 1.295765\n",
      "(Iteration 4701 / 12250) loss: 1.483801\n",
      "(Iteration 4801 / 12250) loss: 1.518883\n",
      "(Epoch 10 / 25) train acc: 0.539000; val_acc: 0.496000\n",
      "(Iteration 4901 / 12250) loss: 1.534681\n",
      "(Iteration 5001 / 12250) loss: 1.531163\n",
      "(Iteration 5101 / 12250) loss: 1.683908\n",
      "(Iteration 5201 / 12250) loss: 1.429279\n",
      "(Iteration 5301 / 12250) loss: 1.464780\n",
      "(Epoch 11 / 25) train acc: 0.548000; val_acc: 0.523000\n",
      "(Iteration 5401 / 12250) loss: 1.309413\n",
      "(Iteration 5501 / 12250) loss: 1.436251\n",
      "(Iteration 5601 / 12250) loss: 1.525939\n",
      "(Iteration 5701 / 12250) loss: 1.464295\n",
      "(Iteration 5801 / 12250) loss: 1.463938\n",
      "(Epoch 12 / 25) train acc: 0.569000; val_acc: 0.508000\n",
      "(Iteration 5901 / 12250) loss: 1.330737\n",
      "(Iteration 6001 / 12250) loss: 1.582641\n",
      "(Iteration 6101 / 12250) loss: 1.488923\n",
      "(Iteration 6201 / 12250) loss: 1.657280\n",
      "(Iteration 6301 / 12250) loss: 1.538757\n",
      "(Epoch 13 / 25) train acc: 0.581000; val_acc: 0.529000\n",
      "(Iteration 6401 / 12250) loss: 1.442942\n",
      "(Iteration 6501 / 12250) loss: 1.377621\n",
      "(Iteration 6601 / 12250) loss: 1.435667\n",
      "(Iteration 6701 / 12250) loss: 1.512683\n",
      "(Iteration 6801 / 12250) loss: 1.496492\n",
      "(Epoch 14 / 25) train acc: 0.585000; val_acc: 0.533000\n",
      "(Iteration 6901 / 12250) loss: 1.504566\n",
      "(Iteration 7001 / 12250) loss: 1.320004\n",
      "(Iteration 7101 / 12250) loss: 1.564026\n",
      "(Iteration 7201 / 12250) loss: 1.464634\n",
      "(Iteration 7301 / 12250) loss: 1.578758\n",
      "(Epoch 15 / 25) train acc: 0.574000; val_acc: 0.536000\n",
      "(Iteration 7401 / 12250) loss: 1.395931\n",
      "(Iteration 7501 / 12250) loss: 1.458254\n",
      "(Iteration 7601 / 12250) loss: 1.429322\n",
      "(Iteration 7701 / 12250) loss: 1.374497\n",
      "(Iteration 7801 / 12250) loss: 1.447083\n",
      "(Epoch 16 / 25) train acc: 0.580000; val_acc: 0.540000\n",
      "(Iteration 7901 / 12250) loss: 1.463296\n",
      "(Iteration 8001 / 12250) loss: 1.481594\n",
      "(Iteration 8101 / 12250) loss: 1.383514\n",
      "(Iteration 8201 / 12250) loss: 1.254411\n",
      "(Iteration 8301 / 12250) loss: 1.312277\n",
      "(Epoch 17 / 25) train acc: 0.592000; val_acc: 0.539000\n",
      "(Iteration 8401 / 12250) loss: 1.495808\n",
      "(Iteration 8501 / 12250) loss: 1.384110\n",
      "(Iteration 8601 / 12250) loss: 1.350851\n",
      "(Iteration 8701 / 12250) loss: 1.477194\n",
      "(Iteration 8801 / 12250) loss: 1.347809\n",
      "(Epoch 18 / 25) train acc: 0.581000; val_acc: 0.538000\n",
      "(Iteration 8901 / 12250) loss: 1.516582\n",
      "(Iteration 9001 / 12250) loss: 1.312336\n",
      "(Iteration 9101 / 12250) loss: 1.517785\n",
      "(Iteration 9201 / 12250) loss: 1.421358\n",
      "(Iteration 9301 / 12250) loss: 1.303145\n",
      "(Epoch 19 / 25) train acc: 0.602000; val_acc: 0.545000\n",
      "(Iteration 9401 / 12250) loss: 1.492987\n",
      "(Iteration 9501 / 12250) loss: 1.385428\n",
      "(Iteration 9601 / 12250) loss: 1.406825\n",
      "(Iteration 9701 / 12250) loss: 1.544376\n",
      "(Epoch 20 / 25) train acc: 0.602000; val_acc: 0.542000\n",
      "(Iteration 9801 / 12250) loss: 1.207486\n",
      "(Iteration 9901 / 12250) loss: 1.175553\n",
      "(Iteration 10001 / 12250) loss: 1.319776\n",
      "(Iteration 10101 / 12250) loss: 1.553778\n",
      "(Iteration 10201 / 12250) loss: 1.294797\n",
      "(Epoch 21 / 25) train acc: 0.606000; val_acc: 0.555000\n",
      "(Iteration 10301 / 12250) loss: 1.321824\n",
      "(Iteration 10401 / 12250) loss: 1.399292\n",
      "(Iteration 10501 / 12250) loss: 1.199056\n",
      "(Iteration 10601 / 12250) loss: 1.405546\n",
      "(Iteration 10701 / 12250) loss: 1.505456\n",
      "(Epoch 22 / 25) train acc: 0.635000; val_acc: 0.542000\n",
      "(Iteration 10801 / 12250) loss: 1.470259\n",
      "(Iteration 10901 / 12250) loss: 1.313425\n",
      "(Iteration 11001 / 12250) loss: 1.250449\n",
      "(Iteration 11101 / 12250) loss: 1.430778\n",
      "(Iteration 11201 / 12250) loss: 1.337175\n",
      "(Epoch 23 / 25) train acc: 0.609000; val_acc: 0.536000\n",
      "(Iteration 11301 / 12250) loss: 1.157953\n",
      "(Iteration 11401 / 12250) loss: 1.445521\n",
      "(Iteration 11501 / 12250) loss: 1.424981\n",
      "(Iteration 11601 / 12250) loss: 1.301358\n",
      "(Iteration 11701 / 12250) loss: 1.240916\n",
      "(Epoch 24 / 25) train acc: 0.611000; val_acc: 0.545000\n",
      "(Iteration 11801 / 12250) loss: 1.452656\n",
      "(Iteration 11901 / 12250) loss: 1.240847\n",
      "(Iteration 12001 / 12250) loss: 1.278877\n",
      "(Iteration 12101 / 12250) loss: 1.571965\n",
      "(Iteration 12201 / 12250) loss: 1.524146\n",
      "(Epoch 25 / 25) train acc: 0.639000; val_acc: 0.548000\n"
     ]
    }
   ],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "model = FullyConnectedNet([300, 300, 300, 300], dropout=0.5, normalization='batchnorm', reg=0.0, weight_scale=1e-2)\n",
    "solver = Solver(model, data, num_epochs=25, batch_size=100, update_rule='adam', optim_config={'learning_rate': 1e-4}, verbose=True, print_every=100)\n",
    "solver.train()\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation set accuracy:  0.557\n",
      "Test set accuracy:  0.55\n"
     ]
    }
   ],
   "source": [
    "best_model = model\n",
    "\n",
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
